ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் ஹெல்பர் மெமரி செயல்திறன்: ஸ்ட்ரீம் செயலாக்க நினைவக தாக்கம்

ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் ஹெல்பர்களான map, filter, மற்றும் reduce போன்றவை, தரவுகளின் தொகுப்புகளுடன் வேலை செய்ய ஒரு சுருக்கமான மற்றும் வெளிப்படையான வழியை வழங்குகின்றன. இந்த ஹெல்பர்கள் குறியீட்டின் வாசிப்புத்திறன் மற்றும் பராமரிப்பு ஆகியவற்றில் குறிப்பிடத்தக்க நன்மைகளை வழங்கினாலும், பெரிய தரவுத்தொகுப்புகள் அல்லது தரவு ஸ்ட்ரீம்களைக் கையாளும் போது அவற்றின் நினைவக செயல்திறன் தாக்கங்களைப் புரிந்துகொள்வது மிகவும் முக்கியம். இந்தக் கட்டுரை இட்டரேட்டர் ஹெல்பர்களின் நினைவகப் பண்புகளை ஆராய்ந்து, திறமையான நினைவகப் பயன்பாட்டிற்காக உங்கள் குறியீட்டை மேம்படுத்துவதற்கான நடைமுறை வழிகாட்டுதலை வழங்குகிறது.

இட்டரேட்டர் ஹெல்பர்களைப் புரிந்துகொள்ளுதல்

இட்டரேட்டர் ஹெல்பர்கள் என்பது இட்டரேபிள்களில் செயல்படும் மெத்தட்கள் ஆகும், இது ஒரு செயல்பாட்டு பாணியில் தரவை மாற்றவும் செயலாக்கவும் உங்களை அனுமதிக்கிறது. அவை ஒன்றாக இணைக்கப்படும் வகையில் வடிவமைக்கப்பட்டுள்ளன, செயல்பாடுகளின் பைப்லைன்களை உருவாக்குகின்றன. உதாரணமாக:

            const numbers = [1, 2, 3, 4, 5];

const squaredEvenNumbers = numbers
  .filter(num => num % 2 === 0)
  .map(num => num * num);

console.log(squaredEvenNumbers); // Output: [4, 16]

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், filter இரட்டைப்படை எண்களைத் தேர்ந்தெடுக்கிறது, மற்றும் map அவற்றை வர்க்கமாக்குகிறது. இந்த சங்கிலித் தொடர் அணுகுமுறை பாரம்பரிய லூப் அடிப்படையிலான தீர்வுகளுடன் ஒப்பிடும்போது குறியீட்டின் தெளிவை கணிசமாக மேம்படுத்தும்.

ஈகர் மதிப்பீட்டின் நினைவக தாக்கங்கள் (Eager Evaluation)

இட்டரேட்டர் ஹெல்பர்களின் நினைவக தாக்கத்தைப் புரிந்துகொள்வதில் ஒரு முக்கியமான அம்சம், அவை ஈகர் அல்லது லேசி மதிப்பீட்டைப் பயன்படுத்துகின்றனவா என்பதுதான். பல நிலையான ஜாவாஸ்கிரிப்ட் அரே மெத்தட்கள், map, filter, மற்றும் reduce (அரேக்களில் பயன்படுத்தும்போது) உட்பட, *ஈகர் மதிப்பீட்டை* (eager evaluation) செய்கின்றன. இதன் பொருள் ஒவ்வொரு செயல்பாடும் ஒரு புதிய இடைநிலை அரேவை உருவாக்குகிறது. நினைவக தாக்கங்களை விளக்க ஒரு பெரிய உதாரணத்தைக் கருத்தில் கொள்வோம்:

            const largeArray = Array.from({ length: 1000000 }, (_, i) => i + 1);

const result = largeArray
  .filter(num => num % 2 === 0)
  .map(num => num * 2)
  .reduce((acc, num) => acc + num, 0);

console.log(result);

            

              
                Copy
              
            
          

இந்த சூழ்நிலையில், filter செயல்பாடு இரட்டைப்படை எண்களை மட்டுமே கொண்ட ஒரு புதிய அரேவை உருவாக்குகிறது. பின்னர், map இரட்டிப்பாக்கப்பட்ட மதிப்புகளுடன் *மற்றொரு* புதிய அரேவை உருவாக்குகிறது. இறுதியாக, reduce கடைசி அரேவை மீண்டும் மீண்டும் கையாளுகிறது. இந்த இடைநிலை அரேக்களை உருவாக்குவது, குறிப்பாக பெரிய உள்ளீட்டு தரவுத்தொகுப்புகளுடன், குறிப்பிடத்தக்க நினைவக நுகர்வுக்கு வழிவகுக்கும். உதாரணமாக, அசல் அரேயில் 1 மில்லியன் கூறுகள் இருந்தால், filter ஆல் உருவாக்கப்பட்ட இடைநிலை அரேயில் சுமார் 500,000 கூறுகள் இருக்கலாம், மேலும் map ஆல் உருவாக்கப்பட்ட இடைநிலை அரேயிலும் சுமார் 500,000 கூறுகள் இருக்கும். இந்த தற்காலிக நினைவக ஒதுக்கீடு பயன்பாட்டிற்கு கூடுதல் சுமையை சேர்க்கிறது.

சோம்பல் மதிப்பீடு மற்றும் ஜெனரேட்டர்கள் (Lazy Evaluation and Generators)

ஈகர் மதிப்பீட்டின் நினைவகத் திறனற்ற தன்மைகளைச் சமாளிக்க, ஜாவாஸ்கிரிப்ட் *ஜெனரேட்டர்கள்* மற்றும் *சோம்பல் மதிப்பீடு* (lazy evaluation) என்ற கருத்தை வழங்குகிறது. ஜெனரேட்டர்கள், முழு அரேக்களையும் நினைவகத்தில் முன்கூட்டியே உருவாக்காமல், தேவைக்கேற்ப மதிப்புகளின் வரிசையை உருவாக்கும் செயல்பாடுகளை வரையறுக்க உங்களை அனுமதிக்கின்றன. தரவு படிப்படியாக வரும் ஸ்ட்ரீம் செயலாக்கத்திற்கு இது குறிப்பாக பயனுள்ளதாக இருக்கும்.

            function* evenNumbers(numbers) {
  for (const num of numbers) {
    if (num % 2 === 0) {
      yield num;
    }
  }
}

function* doubledNumbers(numbers) {
  for (const num of numbers) {
    yield num * 2;
  }
}

const numbers = [1, 2, 3, 4, 5, 6];

const evenNumberGenerator = evenNumbers(numbers);
const doubledNumberGenerator = doubledNumbers(evenNumberGenerator);

for (const num of doubledNumberGenerator) {
  console.log(num);
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், evenNumbers மற்றும் doubledNumbers ஆகியவை ஜெனரேட்டர் செயல்பாடுகளாகும். அவை அழைக்கப்படும் போது, ​​அவை கோரப்படும் போது மட்டுமே மதிப்புகளை உருவாக்கும் இட்டரேட்டர்களைத் திருப்பித் தரும். for...of லூப் doubledNumberGenerator இலிருந்து மதிப்புகளைப் பெறுகிறது, இது evenNumberGenerator இலிருந்து மதிப்புகளைக் கோருகிறது, மற்றும் பல. இடைநிலை அரேக்கள் எதுவும் உருவாக்கப்படவில்லை, இது குறிப்பிடத்தக்க நினைவகச் சேமிப்பிற்கு வழிவகுக்கிறது.

சோம்பல் இட்டரேட்டர் ஹெல்பர்களை செயல்படுத்துதல்

ஜாவாஸ்கிரிப்ட் நேரடியாக அரேக்களில் உள்ளமைக்கப்பட்ட சோம்பல் இட்டரேட்டர் ஹெல்பர்களை வழங்கவில்லை என்றாலும், ஜெனரேட்டர்களைப் பயன்படுத்தி உங்கள் சொந்தமாக எளிதாக உருவாக்கலாம். map மற்றும் filter இன் சோம்பல் பதிப்புகளை நீங்கள் எவ்வாறு செயல்படுத்தலாம் என்பது இங்கே:

            function* lazyMap(iterable, callback) {
  for (const item of iterable) {
    yield callback(item);
  }
}

function* lazyFilter(iterable, predicate) {
  for (const item of iterable) {
    if (predicate(item)) {
      yield item;
    }
  }
}

const largeArray = Array.from({ length: 1000000 }, (_, i) => i + 1);

const lazyEvenNumbers = lazyFilter(largeArray, num => num % 2 === 0);
const lazyDoubledNumbers = lazyMap(lazyEvenNumbers, num => num * 2);

let sum = 0;
for (const num of lazyDoubledNumbers) {
  sum += num;
}

console.log(sum);

            

              
                Copy
              
            
          

இந்தச் செயலாக்கம் இடைநிலை அரேக்களை உருவாக்குவதைத் தவிர்க்கிறது. ஒவ்வொரு மதிப்பும் மறு செய்கையின் போது தேவைப்படும்போது மட்டுமே செயலாக்கப்படும். இந்த அணுகுமுறை குறிப்பாக மிகப் பெரிய தரவுத்தொகுப்புகள் அல்லது எல்லையற்ற தரவு ஸ்ட்ரீம்களைக் கையாளும் போது நன்மை பயக்கும்.

ஸ்ட்ரீம் செயலாக்கம் மற்றும் நினைவகத் திறன்

ஸ்ட்ரீம் செயலாக்கம் என்பது தரவை ஒரே நேரத்தில் நினைவகத்தில் ஏற்றுவதற்குப் பதிலாக, தொடர்ச்சியான ஓட்டமாகக் கையாள்வதை உள்ளடக்கியது. ஜெனரேட்டர்களுடன் சோம்பல் மதிப்பீடு ஸ்ட்ரீம் செயலாக்க சூழ்நிலைகளுக்கு மிகவும் பொருத்தமானது. ஒரு கோப்பிலிருந்து தரவைப் படிப்பது, அதை வரி வரியாகச் செயலாக்குவது, மற்றும் முடிவுகளை மற்றொரு கோப்பில் எழுதுவது போன்ற ஒரு சூழ்நிலையைக் கவனியுங்கள். ஈகர் மதிப்பீட்டைப் பயன்படுத்துவதற்கு முழு கோப்பையும் நினைவகத்தில் ஏற்ற வேண்டியிருக்கும், இது பெரிய கோப்புகளுக்கு சாத்தியமற்றதாக இருக்கலாம். சோம்பல் மதிப்பீட்டின் மூலம், ஒவ்வொரு வரியையும் அது படிக்கப்படும்போது செயலாக்கலாம், இது நினைவகப் பயன்பாட்டைக் குறைக்கிறது.

எடுத்துக்காட்டு: ஒரு பெரிய லாக் கோப்பைச் செயலாக்குதல்

உங்களிடம் ஒரு பெரிய லாக் கோப்பு, சாத்தியமான ஜிகாபைட்கள் அளவில் இருப்பதாக கற்பனை செய்து பாருங்கள், மேலும் சில நிபந்தனைகளின் அடிப்படையில் குறிப்பிட்ட உள்ளீடுகளை நீங்கள் பிரித்தெடுக்க வேண்டும். பாரம்பரிய அரே மெத்தட்களைப் பயன்படுத்தி, முழு கோப்பையும் ஒரு அரேவில் ஏற்ற முயற்சி செய்யலாம், அதை வடிகட்டி, பின்னர் வடிகட்டப்பட்ட உள்ளீடுகளைச் செயலாக்கலாம். இது எளிதில் நினைவகப் பற்றாக்குறைக்கு வழிவகுக்கும். அதற்கு பதிலாக, ஜெனரேட்டர்களுடன் ஸ்ட்ரீம் அடிப்படையிலான அணுகுமுறையைப் பயன்படுத்தலாம்.

            const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

function* filterLines(lines, keyword) {
  for (const line of lines) {
    if (line.includes(keyword)) {
      yield line;
    }
  }
}

async function processLogFile(filePath, keyword) {
  const lines = readLines(filePath);
  const filteredLines = filterLines(lines, keyword);

  for await (const line of filteredLines) {
    console.log(line); // Process each filtered line
  }
}

// Example usage
processLogFile('large_log_file.txt', 'ERROR');

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், readLines ஆனது readline ஐப் பயன்படுத்தி கோப்பை வரி வரியாகப் படித்து ஒவ்வொரு வரியையும் ஒரு ஜெனரேட்டராக அளிக்கிறது. filterLines பின்னர் ஒரு குறிப்பிட்ட முக்கிய வார்த்தையின் இருப்பின் அடிப்படையில் இந்த வரிகளை வடிகட்டுகிறது. கோப்பின் அளவைப் பொருட்படுத்தாமல், ஒரே நேரத்தில் ஒரு வரி மட்டுமே நினைவகத்தில் இருப்பது இங்கு முக்கிய நன்மை.

சாத்தியமான சிக்கல்கள் மற்றும் கருத்தில் கொள்ள வேண்டியவை

சோம்பல் மதிப்பீடு குறிப்பிடத்தக்க நினைவக நன்மைகளை வழங்கினாலும், சாத்தியமான குறைபாடுகளைப் பற்றி அறிந்திருப்பது அவசியம்:

• அதிகரித்த சிக்கல்: சோம்பல் இட்டரேட்டர் ஹெல்பர்களைச் செயல்படுத்துவதற்கு பெரும்பாலும் அதிக குறியீடு மற்றும் ஜெனரேட்டர்கள் மற்றும் இட்டரேட்டர்களைப் பற்றிய ஆழமான புரிதல் தேவைப்படுகிறது, இது குறியீட்டின் சிக்கலை அதிகரிக்கும்.
• பிழைதிருத்த சவால்கள்: சோம்பல் மதிப்பீட்டுக் குறியீட்டை பிழைதிருத்துவது, ஈகர் மதிப்பீட்டுக் குறியீட்டை பிழைதிருத்துவதை விட சவாலானதாக இருக்கலாம், ஏனெனில் செயல்படுத்தல் ஓட்டம் குறைவாக நேராக இருக்கலாம்.
• ஜெனரேட்டர் செயல்பாடுகளின் கூடுதல் சுமை: ஜெனரேட்டர் செயல்பாடுகளை உருவாக்குவதும் நிர்வகிப்பதும் சில கூடுதல் சுமைகளை அறிமுகப்படுத்தலாம், இருப்பினும் ஸ்ட்ரீம் செயலாக்க சூழ்நிலைகளில் நினைவகச் சேமிப்புடன் ஒப்பிடும்போது இது பொதுவாக மிகக் குறைவு.
• ஈகர் நுகர்வு (Eager Consumption): ஒரு சோம்பல் இட்டரேட்டரின் ஈகர் மதிப்பீட்டை தற்செயலாக கட்டாயப்படுத்தாமல் கவனமாக இருங்கள். உதாரணமாக, ஒரு ஜெனரேட்டரை ஒரு அரேவாக மாற்றுவது (எ.கா., Array.from() அல்லது ஸ்ப்ரெட் ஆபரேட்டர் ... ஐப் பயன்படுத்துதல்) முழு இட்டரேட்டரையும் உட்கொண்டு அனைத்து மதிப்புகளையும் நினைவகத்தில் சேமிக்கும், இது சோம்பல் மதிப்பீட்டின் நன்மைகளை நீக்கிவிடும்.

நிஜ உலக உதாரணங்கள் மற்றும் உலகளாவிய பயன்பாடுகள்

நினைவக-திறனுள்ள இட்டரேட்டர் ஹெல்பர்கள் மற்றும் ஸ்ட்ரீம் செயலாக்கத்தின் கொள்கைகள் பல்வேறு களங்கள் மற்றும் பிராந்தியங்களில் பொருந்தும். இதோ சில உதாரணங்கள்:

• நிதித் தரவு பகுப்பாய்வு (உலகளாவிய): பங்குச் சந்தை பரிவர்த்தனை பதிவுகள் அல்லது கிரிப்டோகரன்சி வர்த்தகத் தரவு போன்ற பெரிய நிதித் தரவுத்தொகுப்புகளை பகுப்பாய்வு செய்வதற்கு, பெரும்பாலும் அதிக அளவிலான தகவல்களைச் செயலாக்க வேண்டும். நினைவக வளங்களை தீர்ந்து போகாமல் இந்த தரவுத்தொகுப்புகளை செயலாக்க சோம்பல் மதிப்பீட்டைப் பயன்படுத்தலாம்.
• சென்சார் தரவு செயலாக்கம் (IoT - உலகளவில்): இன்டர்நெட் ஆஃப் திங்ஸ் (IoT) சாதனங்கள் சென்சார் தரவுகளின் ஸ்ட்ரீம்களை உருவாக்குகின்றன. இந்தத் தரவை நிகழ்நேரத்தில் செயலாக்குவது, அதாவது ஒரு நகரம் முழுவதும் பரவியுள்ள சென்சார்களிலிருந்து வெப்பநிலை அளவீடுகளை பகுப்பாய்வு செய்வது அல்லது இணைக்கப்பட்ட வாகனங்களிலிருந்து வரும் தரவுகளின் அடிப்படையில் போக்குவரத்து ஓட்டத்தைக் கண்காணிப்பது, ஸ்ட்ரீம் செயலாக்க நுட்பங்களிலிருந்து பெரிதும் பயனடைகிறது.
• லாக் கோப்பு பகுப்பாய்வு (மென்பொருள் மேம்பாடு - உலகளாவிய): முந்தைய எடுத்துக்காட்டில் காட்டப்பட்டுள்ளபடி, சேவையகங்கள், பயன்பாடுகள் அல்லது நெட்வொர்க் சாதனங்களிலிருந்து லாக் கோப்புகளை பகுப்பாய்வு செய்வது மென்பொருள் மேம்பாட்டில் ஒரு பொதுவான பணியாகும். பெரிய லாக் கோப்புகளை நினைவகச் சிக்கல்களை ஏற்படுத்தாமல் திறமையாகச் செயலாக்க முடியும் என்பதை சோம்பல் மதிப்பீடு உறுதி செய்கிறது.
• மரபணு தரவு செயலாக்கம் (சுகாதாரம் - சர்வதேச): டிஎன்ஏ வரிசைகள் போன்ற மரபணு தரவுகளை பகுப்பாய்வு செய்வது, பரந்த அளவிலான தகவல்களைச் செயலாக்குவதை உள்ளடக்கியது. இந்தத் தரவை நினைவக-திறனுள்ள முறையில் செயலாக்க சோம்பல் மதிப்பீட்டைப் பயன்படுத்தலாம், இது ஆராய்ச்சியாளர்கள் வடிவங்கள் மற்றும் நுண்ணறிவுகளை அடையாளம் காண உதவுகிறது, இல்லையெனில் கண்டறிய முடியாததாக இருக்கும்.
• சமூக ஊடக உணர்வு பகுப்பாய்வு (சந்தைப்படுத்தல் - உலகளாவிய): உணர்வுகளைப் பகுப்பாய்வு செய்வதற்கும் போக்குகளை அடையாளம் காண்பதற்கும் சமூக ஊடக ஊட்டங்களைச் செயலாக்குவதற்கு தொடர்ச்சியான தரவு ஸ்ட்ரீம்களைக் கையாள வேண்டும். சோம்பல் மதிப்பீடு சந்தைப்படுத்துபவர்களுக்கு நினைவக வளங்களை ஓவர்லோட் செய்யாமல் இந்த ஊட்டங்களை நிகழ்நேரத்தில் செயலாக்க அனுமதிக்கிறது.

நினைவக மேம்படுத்தலுக்கான சிறந்த நடைமுறைகள்

ஜாவாஸ்கிரிப்ட்டில் இட்டரேட்டர் ஹெல்பர்கள் மற்றும் ஸ்ட்ரீம் செயலாக்கத்தைப் பயன்படுத்தும் போது நினைவக செயல்திறனை மேம்படுத்த, பின்வரும் சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

• முடிந்தவரை சோம்பல் மதிப்பீட்டைப் பயன்படுத்தவும்: குறிப்பாக பெரிய தரவுத்தொகுப்புகள் அல்லது தரவு ஸ்ட்ரீம்களைக் கையாளும் போது, ​​ஜெனரேட்டர்களுடன் சோம்பல் மதிப்பீட்டிற்கு முன்னுரிமை கொடுங்கள்.
• தேவையற்ற இடைநிலை அரேக்களைத் தவிர்க்கவும்: செயல்பாடுகளைத் திறமையாக சங்கிலித் தொடராக்குவதன் மூலமும் சோம்பல் இட்டரேட்டர் ஹெல்பர்களைப் பயன்படுத்துவதன் மூலமும் இடைநிலை அரேக்கள் உருவாவதைக் குறைக்கவும்.
• உங்கள் குறியீட்டை சுயவிவரப்படுத்துங்கள் (Profile): நினைவக இடையூறுகளை அடையாளம் காணவும் அதற்கேற்ப உங்கள் குறியீட்டை மேம்படுத்தவும் சுயவிவரக் கருவிகளைப் பயன்படுத்தவும். Chrome DevTools சிறந்த நினைவக சுயவிவர திறன்களை வழங்குகிறது.
• மாற்று தரவு கட்டமைப்புகளைக் கருத்தில் கொள்ளுங்கள்: பொருத்தமானால், Set அல்லது Map போன்ற மாற்று தரவு கட்டமைப்புகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள், இது சில செயல்பாடுகளுக்கு சிறந்த நினைவக செயல்திறனை வழங்கக்கூடும்.
• வளங்களை முறையாக நிர்வகிக்கவும்: கோப்பு கையாளுதல்கள் மற்றும் நெட்வொர்க் இணைப்புகள் போன்ற வளங்கள், நினைவகக் கசிவுகளைத் தடுக்க இனி தேவைப்படாதபோது அவற்றை விடுவிப்பதை உறுதிசெய்யவும்.
• குளோசர் ஸ்கோப் குறித்து கவனமாக இருங்கள்: குளோசர்கள் தற்செயலாக இனி தேவைப்படாத பொருட்களுக்கான குறிப்புகளை வைத்திருக்கலாம், இது நினைவகக் கசிவுகளுக்கு வழிவகுக்கும். குளோசர்களின் ஸ்கோப் குறித்து கவனமாக இருங்கள் மற்றும் தேவையற்ற மாறிகளைப் பிடிப்பதைத் தவிர்க்கவும்.
• குப்பை சேகரிப்பை மேம்படுத்துங்கள்: ஜாவாஸ்கிரிப்ட்டின் குப்பை சேகரிப்பான் தானாகவே செயல்பட்டாலும், பொருள்கள் இனி தேவைப்படாதபோது குப்பை சேகரிப்பானுக்கு சுட்டிக்காட்டுவதன் மூலம் சில நேரங்களில் செயல்திறனை மேம்படுத்தலாம். மாறிகளை null ஆக அமைப்பது சில நேரங்களில் உதவும்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் ஹெல்பர்களின் நினைவக செயல்திறன் தாக்கங்களைப் புரிந்துகொள்வது திறமையான மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு முக்கியமானது. ஜெனரேட்டர்களுடன் சோம்பல் மதிப்பீட்டைப் பயன்படுத்துவதன் மூலமும், நினைவக மேம்படுத்தலுக்கான சிறந்த நடைமுறைகளைக் கடைப்பிடிப்பதன் மூலமும், குறிப்பாக பெரிய தரவுத்தொகுப்புகள் மற்றும் ஸ்ட்ரீம் செயலாக்க சூழ்நிலைகளைக் கையாளும் போது, ​​நீங்கள் நினைவக நுகர்வைக் கணிசமாகக் குறைத்து, உங்கள் குறியீட்டின் செயல்திறனை மேம்படுத்தலாம். நினைவக இடையூறுகளை அடையாளம் காண உங்கள் குறியீட்டை சுயவிவரப்படுத்தவும், உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கிற்கு மிகவும் பொருத்தமான தரவு கட்டமைப்புகள் மற்றும் அல்காரிதம்களைத் தேர்ந்தெடுக்கவும் நினைவில் கொள்ளுங்கள். நினைவகத்தை கருத்தில் கொண்ட அணுகுமுறையை மேற்கொள்வதன் மூலம், நீங்கள் செயல்திறன் மற்றும் வளம் சார்ந்த ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்கலாம், இது உலகெங்கிலும் உள்ள பயனர்களுக்கு பயனளிக்கும்.